package com.hjq.service.impl;

import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.hjq.common.PageResult;
import com.hjq.entity.dto.ChapterNodeDTO;
import com.hjq.entity.po.Course;
import com.hjq.entity.vo.CourseDetailVO;
import com.hjq.entity.vo.CourseSearchVO;
import com.hjq.mapper.ChapterMapper;
import com.hjq.mapper.CourseMapper;
import com.hjq.service.CourseService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.time.LocalDateTime;
import java.util.*;

@Service
@Slf4j
public class CourseServiceImpl implements CourseService {
    @Autowired
    private CourseMapper courseMapper;
    @Autowired
    private ChapterMapper chapterMapper;

    @Override
    public PageResult<Course> findByCondition(CourseSearchVO courseSearchVO) {
        if(courseSearchVO.getPageNum()==null){
            courseSearchVO.setPageNum(1);
        }
        if(courseSearchVO.getPageSize()==null){
            courseSearchVO.setPageSize(10);
        }

        // 开启分页，必须紧跟在查询语句之前
        PageHelper.startPage(courseSearchVO.getPageNum(), courseSearchVO.getPageSize());

        // 执行查询
        List<Course> courseList = courseMapper.findByCondition(courseSearchVO);

        PageInfo<Course> pageInfo = new PageInfo<>(courseList);

        // 封装分页结果
        return new PageResult<>(pageInfo.getList(), pageInfo.getTotal());
    }

    @Override
    public CourseDetailVO findDetailById(Long id) {
        // id查找课程的基本信息
        CourseDetailVO courseDetailVO= courseMapper.findById(id);

        // 根据课程id查找出章节列表
        List<ChapterNodeDTO> chapterList = chapterMapper.findDetailByCourseId(id);

        // 转换为树形结构
        List<ChapterNodeDTO> chapterTree = buildChapterTree(chapterList);
        courseDetailVO.setChapterList(chapterTree);
        return courseDetailVO;
    }

    @Override
    public Integer deleteById(Integer id) {
        return  courseMapper.deleteById(id);
    }

    @Override
    public Integer update(Course course) {
        course.setUpdatedAt(LocalDateTime.now());
        return courseMapper.update(course);
    }

    /**
     * 构建章节树
     * @param flatChapters 章节列表
     * @return 章节树
     */
    public List<ChapterNodeDTO> buildChapterTree(List<ChapterNodeDTO> flatChapters) {
        // 1. 用Map存储：key=章节ID，value=章节节点（方便快速查找父节点）
        Map<Long, ChapterNodeDTO> chapterMap = new HashMap<>();
        for (ChapterNodeDTO node : flatChapters) {
            node.setSubchapters(new ArrayList<>()); // 初始化子章节列表
            chapterMap.put(node.getId(), node);
        }

        // 2. 遍历所有节点，将子节点添加到父节点的children中
        List<ChapterNodeDTO> rootNodes = new ArrayList<>(); // 最终的根节点列表（目录树的顶层）
        for (ChapterNodeDTO node : flatChapters) {
            Long parentId = node.getParentId();
            if (parentId == 0) {
                // 父ID为0，是根节点，直接加入根列表
                rootNodes.add(node);
            } else {
                // 非根节点，找到父节点，将当前节点加入父节点的children
                ChapterNodeDTO parentNode = chapterMap.get(parentId);
                if (parentNode != null) {
                    parentNode.getSubchapters().add(node);
                }
            }
        }

        return rootNodes; // 返回根节点列表，每个根节点下嵌套子节点，即目录树
    }
}
